package 时间类

import (
	"fmt"
	"time"
)

// Parse parses a standard time string as a Carbon instance.
// 将标准格式时间字符串解析成 Carbon 实例
func X解析文本时间(值 string, 时区 ...string) *Carbon {
	if 值 == "" {
		return nil
	}
	c := X创建()
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否有错误() {
		return c
	}
	switch 值 {
	case "now":
		return X创建并按当前时间(c.X取时区位置())
	case "yesterday":
		return X创建并按昨天时间(c.X取时区位置())
	case "tomorrow":
		return X创建并按明天时间(c.X取时区位置())
	}
	for i := range defaultLayouts {
		if tt, err := time.ParseInLocation(defaultLayouts[i], 值, c.loc); err == nil {
			c.time = tt
			c.layout = defaultLayouts[i]
			return c
		}
	}
	c.X错误 = X错误_解析失败(值)
	return c
}

// ParseByLayout parses a time string as a Carbon instance by a confirmed layout
// 通过一个确认的 布局模板 将时间字符串解析成 Carbon 实例
func X解析时间并按模板(值, 模板 string, 时区 ...string) *Carbon {
	if 值 == "" {
		return nil
	}
	c := X创建()
	if 模板 == "" {
		c.X错误 = X错误_布局模板_空()
		return c
	}
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否有错误() {
		return c
	}
	if 模板 == X常量_布局模板_Timestamp {
		ts, err := parseTimestamp(值)
		if err != nil {
			c.X错误 = err
			return c
		}
		return X创建并按秒时间戳(ts, c.X取时区位置())
	}
	if 模板 == X常量_布局模板_TimestampMilli {
		ts, err := parseTimestamp(值)
		if err != nil {
			c.X错误 = err
			return c
		}
		return X创建并按毫秒时间戳(ts, c.X取时区位置())
	}
	if 模板 == X常量_布局模板_TimestampMicro {
		ts, err := parseTimestamp(值)
		if err != nil {
			c.X错误 = err
			return c
		}
		return X创建并按微秒时间戳(ts, c.X取时区位置())
	}
	if 模板 == X常量_布局模板_TimestampNano {
		ts, err := parseTimestamp(值)
		if err != nil {
			c.X错误 = err
			return c
		}
		return X创建并按纳秒秒时间戳(ts, c.X取时区位置())
	}
	tt, err := time.ParseInLocation(模板, 值, c.loc)
	if err != nil {
		c.X错误 = fmt.Errorf("%w: %w", X错误_布局模板_不匹配(值, 模板), c.X错误)
		return c
	}
	c.time = tt
	c.layout = 模板
	return c
}

// ParseByFormat parses a time string as a Carbon instance by a confirmed format.
// 通过一个确认的 格式模板 将时间字符串解析成 Carbon 实例
func X解析时间并按格式(值, 格式 string, 时区 ...string) *Carbon {
	if 值 == "" {
		return nil
	}
	if 格式 == "" {
		c := X创建()
		c.X错误 = X错误_格式模板_空()
		return c
	}
	c := X解析时间并按模板(值, format2layout(格式), 时区...)
	if c.X是否有错误() {
		c.X错误 = fmt.Errorf("%w: %w", X错误_格式模板_不匹配(值, 格式), c.X错误)
	}
	return c
}

// ParseWithLayouts parses a time string as a Carbon instance with multiple fuzzy layouts.
// 通过多个模糊的 布局模板 将时间字符串解析成 Carbon 实例
func X解析时间并按模板s(值 string, 模板s []string, 时区 ...string) *Carbon {
	if 值 == "" {
		return nil
	}
	if len(模板s) == 0 {
		return X解析文本时间(值, 时区...)
	}
	c := X创建()
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否有错误() {
		return c
	}
	for i := range 模板s {
		if tt, err := time.ParseInLocation(模板s[i], 值, c.loc); err == nil {
			c.time = tt
			c.layout = 模板s[i]
			return c
		}
	}
	c.X错误 = X错误_解析失败(值)
	return c
}

// ParseWithFormats parses a time string as a Carbon instance with multiple fuzzy formats.
// 通过多个模糊的 格式模板 将时间字符串解析成 Carbon 实例
func X解析文本时间并按格式s(值 string, 格式s []string, 时区 ...string) *Carbon {
	if 值 == "" {
		return nil
	}
	if len(格式s) == 0 {
		return X解析文本时间(值, 时区...)
	}
	c := X创建()
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否有错误() {
		return c
	}
	var layouts []string
	for i := range 格式s {
		layouts = append(layouts, format2layout(格式s[i]))
	}
	return X解析时间并按模板s(值, layouts, 时区...)
}
